home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 July: Mac OS SDK / Dev.CD Jul 96 SDK / Dev.CD Jul 96 SDK1.toast / Development Kits (Disc 1) / OpenDoc / OpenDoc Development / Debugging Support / OpenDoc Source Code / Storage / Bento / EmbedCtr.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-22  |  20.0 KB  |  616 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        EmbedCtr.cpp
  3.  
  4.     Contains:    Implementation for ODEmbeddedContainer.
  5.  
  6.     Owned by:    Vincent Lo
  7.  
  8.     Copyright:    © 1993-1995 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.         <27>    10/24/95    jpa        1293441: DM/VL: Bento memory reserve &
  13.                                     fatal container err.
  14.         <26>     10/8/95    TJ        Fixes Recomended by Refball
  15.         <25>     8/21/95    VL        1278330, 1278315: Error code cleanup.
  16.         <24>      8/3/95    RR        #1257260: Collapse B classes. Remove
  17.                                     somInit methods. Don't call IsInitialized
  18.                                     or SubclassResponsibility
  19.         <23>     7/21/95    VL        1270320: Dispose ba._buffer from
  20.                                     container->GetID. Dispose prevObjectName
  21.                                     when done. Delete _fHandlers in somUninit.
  22.         <22>     5/26/95    VL        1251403: Multithreading naming support.
  23.         <21>     5/25/95    jpa        Fixed usage of ODDebug. [1253321]
  24.         <20>     4/25/95    VL        1210982: Removed 5$.
  25.         <19>     3/31/95    EL        1234685: Get merge target during open
  26.                                     rather than close, this would ensure
  27.                                     getting the right target and not some
  28.                                     corrrupted embedded container.
  29.         <18>     3/24/95    EL        1182275: We don't need to try to merge if
  30.                                     it is read only.
  31.         <17>      3/6/95    EL        1182275: We don't need
  32.                                     DraftPropertiesObject.
  33.         <16>     2/21/95    EL        1182275: Add SetDraftPropertiesObject and
  34.                                     call CMKeepObject with it before closing.
  35.         <15>     2/17/95    EL        1182275: Actually merge embedded
  36.                                     containers.
  37.         <14>     2/15/95    EL        1182275: Add private method SetMergeFlag.
  38.         <13>    11/14/94    VL        1188257: Use Bento errors in BenotDef.h.
  39.         <12>     11/1/94    VL        1151339: Preparation for MergeContainer.
  40.         <11>    10/19/94    VL        1155857: Commented out check for
  41.                                     cmContainer permission in Close. This
  42.                                     should fix "Cannot create  more than 10
  43.                                     drafts" problem.
  44.         <10>     9/23/94    VL        1184272: ContainerID is now a sequence of
  45.                                     octets. This affects EmbeddedContainers
  46.                                     also.
  47.          <9>     8/26/94    EL        #1182275 Include code (not yet active) for
  48.                                     merging of container.
  49.          <8>     8/10/94    NP        Added QDFixM.h.
  50.          <7>      8/5/94    VL        1171603: Use somSelf->GetCMSession instead
  51.                                     of depending on ODStorageSystem.
  52.          <6>      8/3/94    VL        1153123: Storage to ODStor.
  53.          <5>     7/11/94    VL        Fixed a bug in uninit. Close should not be
  54.                                     called on an Embedded Container. (Bug was
  55.                                     introduced during SOM conversion).
  56.          <4>      7/7/94    VL        Fixed the reversal of conditional in Abort
  57.                                     (this bug was introduced during the SOM
  58.                                     conversion).
  59.          <3>      7/5/94    VL        Added GetUseMode.
  60.          <2>      7/1/94    jpa        Fixed implicit casts from void*.
  61.          <1>     6/30/94    CC        first checked in
  62.          <0>     6/28/94    SV        SOMverted
  63.          <2>     4/13/94    VL        1157028: StorageM.h does not include
  64.                                     CMAPI.h anymore, so GetCMSession returns
  65.                                     ODULong.
  66.          <1>     3/24/94    VL        first checked in
  67.          <3>      3/1/94    JA        Moved string const here from .h file.
  68.                                     (1147295)
  69.          <2>     2/17/94    JA        Removed bogus quote in include statement.
  70.         <15>      2/8/94    VL        Correct capitalization and <> for includes.
  71.         <14>      2/8/94    VL        Use new exception macros.
  72.         <13>     1/19/94    EL        Use kCMNextGeneration when opening new
  73.                                     container for update.
  74.         <12>     1/12/94    VL        Init changes.
  75.         <11>     12/3/93    TÇ        Stop including ODError.h, it is included
  76.                                     as ErrorDef.h inside Except.h
  77.         <10>    11/23/93    VL        Made EmbeddedContainer pool-aware.
  78.          <9>      8/9/93    VL        Moved error code to ODError.h.
  79.          <8>     7/30/93    VL        ODContainerName* should be
  80.                                     ODContainerName.
  81.          <7>      7/6/93    VL        ODContainerName should be
  82.                                     ODContainerName*.
  83.          <6>     6/30/93    VL        Changed ODName to ODType.
  84.          <5>     6/30/93    VL        Removed ODDocument::Reopen in Abort() &
  85.                                     Close(). Open() checks for fContainer
  86.                                     instead of fUseMode.
  87.          <4>     6/22/93    VL        Used RefCount from ODRefCntObject. Added
  88.                                     Abort.
  89.          <3>     6/15/93    VL        Reopen drafts after Close.
  90.          <2>      6/1/93    VL        Changed open mode on CMOpenContainer in
  91.                                     Open.
  92.          <1>     5/27/93    VL        first checked in
  93.  
  94.     To Do:
  95.         Eliminate shouldMerge in containerID.
  96.     In Progress:
  97.         
  98. */
  99.  
  100. #ifndef _QDFIXM_
  101. #include "QDFixM.h"
  102. #endif
  103.  
  104. #ifndef _PLFMDEF_
  105. #include "PlfmDef.h"
  106. #endif
  107.  
  108.  
  109. #define ODEmbeddedContainer_Class_Source
  110. #define VARIABLE_MACROS
  111. #include <EmbedCtr.xih>
  112.  
  113. #ifndef SOM_ODRefCntObject_xh
  114. #include <RefCtObj.xh>
  115. #endif
  116.  
  117. #ifndef SOM_ODStorageSystem_xh
  118. #include <ODStor.xh>
  119. #endif
  120.  
  121. #ifndef _SESSHDR_
  122. #include "SessHdr.h"        // for sessionRoutinesMetahandler
  123. #endif
  124.  
  125. #ifndef _EMBEDHDR_
  126. #include "EmbedHdr.h"
  127. #endif
  128.  
  129. #ifndef _TARGTHDR_
  130. #include "TargtHdr.h"
  131. #endif
  132.  
  133. #ifndef __CM_API__
  134. #include "CMAPI.h"
  135. #endif
  136.  
  137. #ifndef _EXCEPT_
  138. #include "Except.h"
  139. #endif
  140.  
  141. #ifndef _INDHDR_
  142. #include "IndHdr.h"
  143. #endif
  144.  
  145. #ifndef _ODNEW_
  146. #include "ODNew.h"
  147. #endif
  148.  
  149. #ifndef __STRING__
  150. #include <string.h>        // for strlen
  151. #endif
  152.  
  153.  
  154.  
  155. //==============================================================================
  156. // Constants
  157. //==============================================================================
  158. const ODType kODEmbeddedContainerTypeName = "EmbedHdr";
  159.  
  160. #if ODDebug
  161. // #define ODDebug_EmbedCtr 1
  162. #endif
  163.  
  164. #pragma segment EmbedCtr
  165.  
  166. //==============================================================================
  167. // ODEmbeddedContainer
  168. //==============================================================================
  169.  
  170. //------------------------------------------------------------------------------
  171. // ODEmbeddedContainer: GetName
  172. //------------------------------------------------------------------------------
  173.  
  174. SOM_Scope ODContainerName  SOMLINK ODEmbeddedContainerGetName(ODEmbeddedContainer *somSelf, Environment *ev)
  175. {
  176.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  177.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","GetName");
  178.  
  179.     WARN("EmbeddedContainer does not have a name.");
  180.     
  181.     // The following two lines are used to pacify the compiler.
  182.     // They should never be executed.
  183.     ODIText    dummy;
  184.     return     dummy;
  185. }
  186.  
  187. //------------------------------------------------------------------------------
  188. // ODEmbeddedContainer: SetName
  189. //------------------------------------------------------------------------------
  190.  
  191. SOM_Scope void  SOMLINK ODEmbeddedContainerSetName(ODEmbeddedContainer *somSelf, Environment *ev,
  192.         ODContainerName* name)
  193. {
  194.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  195.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","SetName");
  196.  
  197.     // This function is an no-op.
  198. }
  199.  
  200. //------------------------------------------------------------------------------
  201. // ODEmbeddedContainer: AcquireDocument
  202. //------------------------------------------------------------------------------
  203.  
  204. SOM_Scope ODDocument*  SOMLINK ODEmbeddedContainerAcquireDocument(ODEmbeddedContainer *somSelf, Environment *ev,
  205.         ODDocumentID id)
  206. {
  207.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  208.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","AcquireDocument");
  209.  
  210. ODUnused(id);
  211.  
  212.     return kODNULL;
  213. }
  214.  
  215. //------------------------------------------------------------------------------
  216. // ODEmbeddedContainer: Release
  217. //------------------------------------------------------------------------------
  218.  
  219. SOM_Scope void  SOMLINK ODEmbeddedContainerRelease(ODEmbeddedContainer *somSelf, Environment *ev)
  220. {
  221.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  222.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Release");
  223.  
  224.     ODEmbeddedContainer_parent_ODBentoContainer_Release(somSelf, ev);
  225. }
  226.  
  227. //------------------------------------------------------------------------------
  228. // ODEmbeddedContainer: ~ODEmbeddedContainer
  229. //------------------------------------------------------------------------------
  230.  
  231. SOM_Scope void  SOMLINK ODEmbeddedContainersomUninit(ODEmbeddedContainer *somSelf)
  232. {
  233.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  234.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","somUninit");
  235.  
  236. #ifdef DebugRefCount
  237.     printf("~ODEmbeddedContainer %x CMContainer %x\n", somSelf, _fContainer);
  238.     fflush(stdout);
  239. #endif
  240.  
  241.     Environment* ev = somGetGlobalEnvironment ();
  242.  
  243. //    if (_fCMContainer != kODNULL)
  244. //        somSelf->Close(ev);
  245.  
  246.     if (_fHandlers != kODNULL)
  247.         delete _fHandlers;
  248.  
  249. //    Theoretically, we should not delete the ID because they should be able to 
  250. //    be reused.
  251. //
  252. //    ODContainerID id = somSelf->GetID(ev);
  253. //    if (id != kXMPNULL)
  254. //        delete id;
  255.  
  256.     ODEmbeddedContainer_parent_ODBentoContainer_somUninit(somSelf);
  257. }
  258.  
  259. //------------------------------------------------------------------------------
  260. // ODEmbeddedContainer: InitContainer
  261. //------------------------------------------------------------------------------
  262.  
  263. SOM_Scope void  SOMLINK ODEmbeddedContainerInitContainer(ODEmbeddedContainer *somSelf, Environment *ev,
  264.         ODStorageSystem* storage,
  265.         ODContainerID* id)
  266. {
  267.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  268.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","InitContainer");
  269.  
  270.     SOM_CATCH return;
  271.  
  272.     /* Moved from somInit. SOM itself sets fields to zero
  273.     _fCMContainer = kODNULL;
  274.     _fHandlers = kODNULL;
  275.     _fTargetValue = kODNULL;
  276.     */
  277.     _fUseMode = kCMReading;
  278.     _fShouldMerge = kODTrue;
  279.  
  280.     ODEmbeddedContainer_parent_ODBentoContainer_InitContainer(somSelf, ev, storage, id);
  281.  
  282.     
  283.     ODByteArray ba = somSelf->GetID(ev);
  284.     ODEmbeddedContainerID    containerID = *((ODEmbeddedContainerID*) ba._buffer);
  285. //    _fShouldMerge = containerID.shouldMerge;
  286.     _fHandlers = new(somSelf->GetHeap(ev)) ODEmbeddedHandlers(somSelf->GetCMSession(ev),
  287.                                                                 containerID.cmValue);
  288.     _fHandlers->Initialize();
  289.  
  290.     ODDisposePtr(ba._buffer);
  291.  
  292. }
  293.  
  294. //------------------------------------------------------------------------------
  295. // ODEmbeddedContainer: Create
  296. //------------------------------------------------------------------------------
  297.  
  298. SOM_Scope ODContainer*  SOMLINK ODEmbeddedContainerCreate(ODEmbeddedContainer *somSelf, Environment *ev)
  299. {
  300.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  301.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Create");
  302.  
  303.     SOM_CATCH return (ODContainer*) kODNULL;
  304.  
  305.     if (_fCMContainer == kODNULL) {
  306.  
  307.         CMSession cmSession = somSelf->GetCMSession(ev);
  308.         if (cmSession == kODNULL)
  309.             THROW(kODErrCannotCreateContainer);
  310.  
  311. //        ODType    prevObjectName = _fID->GetPrevObjectName();
  312.  
  313.         ODByteArray    ba = somSelf->GetID(ev);
  314.         CMValue cmValue = *((CMValue*) ba._buffer);
  315.         ODType prevObjectName = (ODType) CMGetValueRefCon(cmValue);
  316.         ODDisposePtr(ba._buffer);
  317.  
  318.         // Just to be safe, we are calling this even though we may have called this
  319.         // already for some other containers.
  320.         CMSetMetaHandler(cmSession,
  321.                         (CMGlobalName) CMTargetHandlersTypeName,
  322.                         targetContainerMetahandler);
  323.  
  324.         CMSetMetaHandler(cmSession, 
  325.                             kODIndirectValueGlobalName, 
  326.                             IndirectDynamicValueMetahandler);
  327.  
  328.         if (prevObjectName != kODNULL) {
  329. #if MergeContainersAvailable
  330.             CMValue             embeddedValue;
  331.             CMContainer            fileContainer;
  332.             CMObject            embeddedObject;
  333.             CMProperty            embeddedCntProp, targetObjectProp;
  334.             CMType                embeddedCntType;
  335.             CMObject            prevObject;
  336.             
  337.             _fCMContainer = CMOpenNewContainer(cmSession,
  338.                                         _fHandlers,
  339.                                         kODEmbeddedContainerTypeName,
  340.                                         (CMContainerUseMode) (kCMUpdateTarget+kCMMerging+kCMReuseFreeSpace),
  341.                                         kCMNextGeneration, kCMDefaultEndian,
  342.                                         prevObjectName);
  343.             if (_fCMContainer == kODNULL)
  344.                 THROW(kODErrCannotCreateContainer);
  345.             ODVolatile(embeddedObject);
  346.             ODVolatile(embeddedCntProp);
  347.             ODVolatile(embeddedCntType);
  348.             TRY        
  349.                 ODSessionMustHaveCMAllocReserve(_fCMContainer);
  350.                 embeddedValue = _fHandlers->ReturnParentValueHandler();
  351.                 CMGetValueInfo(embeddedValue, &fileContainer, &embeddedObject, 
  352.                                 &embeddedCntProp, &embeddedCntType, kODNULL);
  353.                 targetObjectProp = CMRegisterProperty(fileContainer, prevObjectName);
  354.                 CMGetValueInfo(embeddedValue, &fileContainer, &embeddedObject, 
  355.                                 &embeddedCntProp, &embeddedCntType, NULL);
  356.                 prevObject = CMGetPrevObjectWithProperty(fileContainer, embeddedObject, embeddedCntProp);
  357.                 embeddedObject = CMGetPrevObjectWithProperty(fileContainer, embeddedObject, targetObjectProp);
  358.                 if (prevObject == embeddedObject)
  359.                     CMReleaseObject(prevObject);
  360.                 else {     /* we suspect this is garbage, check if we should delete it     */
  361.                     TRY /* if anything fails, garbage object is not deleted, big deal    */
  362.                         embeddedValue = CMUseValue(prevObject, embeddedCntProp, embeddedCntType);
  363.                         CMReleaseValue(embeddedValue);
  364.                         if (!CMContainsValidLabel(embeddedValue)) {
  365.                             CMReleaseObject(prevObject);
  366.                             CMDeleteObject(prevObject);
  367.                         }
  368.                         else
  369.                             CMReleaseObject(prevObject);
  370.                     ENDTRY
  371.                 }
  372.                 embeddedValue = CMUseValue(embeddedObject, embeddedCntProp, embeddedCntType);
  373.                 ODSessionRestoreCMAllocReserve(_fCMContainer);
  374.             CATCH_ALL
  375.                 embeddedValue = kODNULL;
  376.             ENDTRY
  377.             _fTargetValue = embeddedValue;
  378. #else
  379.             _fCMContainer = CMOpenNewContainer(cmSession,
  380.                                         _fHandlers,
  381.                                         kODEmbeddedContainerTypeName,
  382.                                         (CMContainerUseMode) (kCMUpdateTarget),
  383.                                         kCMNextGeneration, kCMDefaultEndian,
  384.                                         prevObjectName);
  385. #endif
  386.             _fUseMode = kCMUpdateTarget;
  387.             ODDisposePtr(prevObjectName);
  388.             CMSetValueRefCon(cmValue, kODNULL);
  389.         }
  390.         else {
  391.             _fCMContainer = CMOpenNewContainer(cmSession,
  392.                                         _fHandlers,
  393.                                         kODEmbeddedContainerTypeName,
  394.                                         (CMContainerUseMode) (kCMWriting),
  395.                                         kCMNextGeneration, kCMDefaultEndian);
  396.             _fUseMode = kCMWriting;
  397.         }
  398.         
  399.         if (_fCMContainer == kODNULL)
  400.             THROW(kODErrCannotCreateContainer);
  401.             
  402.     }
  403.  
  404.  
  405.     return somSelf;
  406. }
  407.  
  408. //------------------------------------------------------------------------------
  409. // ODEmbeddedContainer: Open
  410. //------------------------------------------------------------------------------
  411.  
  412. SOM_Scope ODContainer*  SOMLINK ODEmbeddedContainerOpen(ODEmbeddedContainer *somSelf, Environment *ev)
  413. {
  414.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  415.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Open");
  416.  
  417.     SOM_CATCH return (ODContainer*) kODNULL;
  418.  
  419.     if (_fCMContainer == kODNULL) {
  420.  
  421.         CMSession cmSession = somSelf->GetCMSession(ev);
  422.         if (cmSession == kODNULL)
  423.             THROW(kODErrCannotOpenContainer);
  424.  
  425.         // Just to be safe, we are calling this even though we may have called this
  426.         // already for some other containers.
  427.         CMSetMetaHandler(cmSession,
  428.                         (CMGlobalName) CMTargetHandlersTypeName,
  429.                         targetContainerMetahandler);
  430.  
  431.         CMSetMetaHandler(cmSession, 
  432.                             kODIndirectValueGlobalName, 
  433.                             IndirectDynamicValueMetahandler);
  434.  
  435.         _fCMContainer = CMOpenContainer(cmSession,
  436.                                         _fHandlers,
  437.                                         kODEmbeddedContainerTypeName,
  438.                                         (CMContainerUseMode)(kCMReading));
  439.  
  440.         ODSessionRestoreCMAllocReserve(_fCMContainer);
  441.         
  442.         if (_fCMContainer == kODNULL)
  443.             THROW(kODErrCannotOpenContainer);
  444.  
  445.         _fUseMode = kCMReading;
  446.     }
  447.         
  448.     return somSelf;
  449. }
  450.  
  451. //------------------------------------------------------------------------------
  452. // ODEmbeddedContainer: Close
  453. //------------------------------------------------------------------------------
  454.  
  455. SOM_Scope ODContainer*  SOMLINK ODEmbeddedContainerClose(ODEmbeddedContainer *somSelf, Environment *ev)
  456. {
  457.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  458.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Close");
  459.     
  460.     SOM_CATCH return (ODContainer*) kODNULL;
  461.  
  462.     CMContainer cmContainer = somSelf->GetCMContainer(ev);
  463.     if (_fCMContainer != kODNULL) {
  464.             ODSessionMustHaveCMAllocReserve(_fCMContainer);
  465. //        if (_fUseMode != kCMReading) {
  466. #if MergeContainersAvailable
  467.             if (_fShouldMerge && (_fUseMode != kCMReading)) {
  468. #ifdef ODDebug_EmbedCtr
  469.     somPrintf("Closing EmbedCtr: Merge\n");
  470. #endif
  471.                 CMMergeContainer(_fCMContainer, _fTargetValue);
  472.             }
  473.             else {
  474. #ifdef ODDebug_EmbedCtr
  475.     somPrintf("Closing EmbedCtr: Close\n");
  476. #endif
  477.                 CMCloseContainer(_fCMContainer);
  478.             }
  479.             if (_fTargetValue) {
  480.                 CMReleaseValue(_fTargetValue);
  481.                 _fTargetValue = kODNULL;
  482.             }
  483.  
  484. #else
  485.             CMCloseContainer(_fCMContainer);
  486. #endif
  487.             _fCMContainer = kODNULL;
  488. //        }
  489.     }
  490.     
  491.     return somSelf;
  492. }
  493.  
  494. //------------------------------------------------------------------------------
  495. // ODEmbeddedContainer: Purge
  496. //------------------------------------------------------------------------------
  497.  
  498. SOM_Scope ODSize  SOMLINK ODEmbeddedContainerPurge(ODEmbeddedContainer *somSelf, Environment *ev,
  499.         ODSize size)
  500. {
  501.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  502.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Purge");
  503.  
  504.     ODULong    runningTotal = 0; ODVolatile( runningTotal );
  505.         
  506.     SOM_TRY
  507.          runningTotal = ODEmbeddedContainer_parent_ODBentoContainer_Purge(somSelf, ev, size);
  508.     SOM_CATCH_ALL
  509.         WARN("Error %ld trying to purge in CMDraftPurge",ErrorCode());
  510.         SetErrorCode(kODNoError);        // dh - Eat the exception; Purge should not 
  511.                                         // propagate it because clients function
  512.                                         // fine whether memory was purged or not.
  513.     SOM_ENDTRY
  514.  
  515.     return runningTotal;
  516. }
  517.  
  518. //------------------------------------------------------------------------------
  519. // ODEmbeddedContainer: ReleaseDocument
  520. //------------------------------------------------------------------------------
  521.  
  522. SOM_Scope ODContainer*  SOMLINK ODEmbeddedContainerReleaseDocument(ODEmbeddedContainer *somSelf, Environment *ev,
  523.         ODDocument* document)
  524. {
  525.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  526.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","ReleaseDocument");
  527.  
  528. ODUnused(document);
  529.  
  530.     return somSelf;
  531. }
  532.  
  533. //------------------------------------------------------------------------------
  534. // ODEmbeddedContainer: Abort
  535. //------------------------------------------------------------------------------
  536.  
  537. SOM_Scope ODContainer*  SOMLINK ODEmbeddedContainerAbort(ODEmbeddedContainer *somSelf, Environment *ev)
  538. {
  539.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  540.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Abort");
  541.  
  542. //    SOM_CATCH return (ODContainer*) kODNULL;
  543.  
  544.     CMSize valueSize;
  545.  
  546.     if (_fCMContainer != kODNULL) {
  547.         if (_fUseMode != kCMReading) {
  548.             SOM_TRY
  549.                 ODSessionMustHaveCMAllocReserve(_fCMContainer);
  550.                 CMAbortContainer(_fCMContainer);
  551.                 
  552.                 // Trunc the value as Bento does not do it for us.
  553.                 ODByteArray    ba = somSelf->GetID(ev);
  554.                 CMValue value = *((CMValue*) ba._buffer);
  555.                 ODDisposePtr(ba._buffer);
  556.                 valueSize = CMGetValueSize(value);
  557.                 CMDeleteValueData(value, 0, valueSize);
  558.             SOM_CATCH_ALL
  559.             SOM_ENDTRY
  560.             _fCMContainer = kODNULL;
  561.         }
  562.     }
  563.     
  564.     return somSelf;
  565. }
  566.  
  567. //------------------------------------------------------------------------------
  568. // ODEmbeddedContainer: GetCMContainer
  569. //------------------------------------------------------------------------------
  570.  
  571. SOM_Scope CMContainer  SOMLINK ODEmbeddedContainerGetCMContainer(ODEmbeddedContainer *somSelf, Environment *ev)
  572. {
  573.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  574.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","GetCMContainer");
  575.  
  576.     return _fCMContainer;
  577. }
  578.  
  579. //------------------------------------------------------------------------------
  580. // ODEmbeddedContainer: GetHandlers
  581. //------------------------------------------------------------------------------
  582.  
  583. SOM_Scope ODBentoHandlers*  SOMLINK ODEmbeddedContainerGetHandlers(ODEmbeddedContainer *somSelf, Environment *ev)
  584. {
  585.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  586.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","GetHandlers");
  587.  
  588.     return _fHandlers;
  589. }
  590.  
  591. //------------------------------------------------------------------------------
  592. // ODEmbeddedContainer: GetUseMode
  593. //------------------------------------------------------------------------------
  594.  
  595. SOM_Scope CMContainerUseMode  SOMLINK ODEmbeddedContainerGetUseMode(ODEmbeddedContainer *somSelf, Environment *ev)
  596. {
  597.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  598.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","GetHandlers");
  599.  
  600.     return _fUseMode;
  601. }
  602.  
  603. //------------------------------------------------------------------------------
  604. // ODEmbeddedContainer: SetMergeFlag
  605. //------------------------------------------------------------------------------
  606.  
  607. SOM_Scope void  SOMLINK ODEmbeddedContainerSetMergeFlag(ODEmbeddedContainer *somSelf, Environment *ev,
  608.         ODBoolean flag)
  609. {
  610.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  611.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","SetMergeFlag");
  612.  
  613.     _fShouldMerge = flag;
  614. }
  615.  
  616.